Error correction process and mechanism

ABSTRACT

Performing soft error correction includes receiving a word at a soft correction engine capable of operating in more than one correction mode, identifying soft bit positions within the word, and automatically generating a number of possible results for the received word using combinations of the soft bit positions and the more than one correction modes. The soft correction engine may include a Golay engine.

CROSS REFERENCE TO RELATED APPLICATIONS

This application claims priority from U.S. Provisional Application No.60/310,824, filed Aug. 9, 2001, and titled “Error Correction Process andMechanism,” which is incorporated by reference.

TECHNICAL FIELD

This disclosure relates to an error correction process and mechanism.

BACKGROUND

In a data communication system, it is important to have reliable datatransmission over a transmission medium. There are numerous factors thatmay affect the reliability and integrity of the data transmitted. Forexample, the reliability and integrity of the data transmitted may beaffected by the transmitting system, the transmission medium, and/or thereceiving system.

SUMMARY

In one general aspect, performing soft error correction includesreceiving a word at a soft correction engine capable of operating inmore than one correction mode, identifying soft bit positions within theword, and automatically generating a number of possible results for thereceived word using combinations of the soft bit positions and the morethan one correction modes.

Implementations may include one or more of the following features. Forexample, the several possible results may include default results andalternate results. Within the several possible results, possible correctsolutions may be selected from among at least one of the default resultsand alternate results based on a metric representing a likelihood ofcorrectness. The metric may include a lowest partial correction countvalue.

At least one result from among the number of possible results may beinputted into an error handling engine for error detection. The errorhandling engine may include a cyclic redundancy check (CRC) engine.

In one implementation, from among the several possible results, adefault result and an alternate result may be inputted into an errorhandling engine for selection of a correct solution as between thedefault result and the alternate result. The error handling engine mayinclude a CRC engine. The default result and the alternate result thatdiffers from the default result by one or more words may be inputtedinto the error handling engine for selection of the correct solution asbetween the default result and the alternate result. The soft correctionengine may include a Golay engine.

In another implementation, the word may be received at a secondcorrection engine that is capable of operating in more than onecorrection mode and that is structured and arranged to operate inparallel with the first correction engine. Soft error correction may beperformed, in parallel, on the received word at both the first softcorrection engine and the second soft correction engine. Both the firstsoft correction engine and the second correction engine mayautomatically generate a number of possible results for the receivedword. The first soft correction engine and the second soft correctionengine may include a Golay engine.

In another general aspect, performing error correction includesperforming, at a soft error correction engine, soft error correction ona stream of bits and producing at least one result with a default and analternative and selecting, at an error handling engine, among thedefault and the alternative for the result produced by the soft errorcorrection engine.

Implementations may include one or more of the following features. Forexample, the soft error correction engine may include a Golay engine.The error handling engine may include a CRC engine. The soft errorcorrection engine and the error handling engine may be structured andarranged to operate in series. The alternative may differ from thedefault by one or more words and the error handling engine may selectamong the default and the alternative for the result produced by thesoft error correction engine.

In another general aspect, error detection and correction includesreceiving a default word and an alternate word at an error handlingengine, calculating a first remainder for the default word and a secondremainder for the alternate word, selecting the default word as acorrect result when the first remainder matches a transmitted remainder,and selecting the alternate word as the correct result when the secondremainder matches the transmitted remainder.

Implementations may include one or more of the following features. Forexample, the error handling engine may include a CRC engine. The defaultword and the alternate word may be received from a soft error correctionengine. Soft error correction may be performed at the soft errorcorrection engine to produce the default word and the alternate word andthe default word and the alternate word may be sent to the errorhandling engine. The soft error correction engine may include a Golayengine.

In another general aspect, performing soft error correction includesreceiving a multiple bit word at both a first soft correction engine anda second soft correction engine that are structured and arranged tooperate in parallel. Soft error correction is performed in parallel onthe received multiple bit word at both the first soft correction engineand the second soft correction engine. A first correction result isoutputted at the first soft correction engine and a second correctionresult is outputted at the second soft correction engine.

Implementations may include one or more of the following features. Forexample, soft error correction may be performed in parallel on thereceived multiple bit word at both the first soft correction engine andthe second soft correction engine concurrently. A first correction valuemay be generated at the first soft correction engine and a secondcorrection value may be generated at the second soft correction enginesuch that selecting among the first correction result and the secondcorrection result may be based on a lower value between the firstcorrection value and the second correction value. The first and secondsoft correction engines each may include a Golay engine.

In another general aspect, performing soft error correction includesreceiving a word at a soft correction engine, selecting a soft bitposition other than a bit with a lowest correlation value, andevaluating the selected bit for soft error correction.

Implementations may include one or more of the following features. Forexample, the soft correction engine may include a Golay engine. A bitfor soft error correction may be selected based on the evaluation andsoft error correction may be performed on the selected bit.

These general and specific aspects may be implemented using a system, amethod, or a computer program, or any combination of systems, methods,or computer programs.

Other features will be apparent from the description and drawings, andfrom the claims.

DESCRIPTION OF DRAWINGS

FIG. 1 is a flow chart of an exemplary encoding and transmissionprocess.

FIG. 2 is a flow chart of an exemplary receiving and decoding process.

FIG. 3 a is a block diagram of an exemplary hardware implementationincluding two Golay engines.

FIG. 3 b is a flow chart of an exemplary Golay correction process thatmay be included in the decoding process of FIG. 2.

FIG. 3 c is a flow chart of an expansion of the exemplary Golaycorrection process of FIG. 3 b.

FIG. 4 is a flow chart of an exemplary Cyclic Redundancy Check (CRC)process that may be included in the decoding process of FIG. 2.

FIG. 5 a is a block diagram describing operations that may be performedusing the CRC process described by FIG. 4.

FIG. 5 b is a flow chart of an expansion of the exemplary CRC process ofFIG. 4.

Like reference symbols in the various drawings may indicate likeelements.

DETAILED DESCRIPTION

An error correction mechanism may include several layers of correction.For instance, an error correction may be based on the combination of twolayers of error correction that include an (n, k) error correction usingsoft bits and an error handling engine (e.g., an error detection and/orerror correction process). The error handling engine may include anerror detection engine and/or an error correction engine, such as, forexample, a Cyclic Redundancy Check (CRC) engine.

In one implementation, for example, the first layer includes Golaycorrection (e.g., a Golay engine) and the second layer includes CRCerror block detection and correction (e.g., a CRC error block detectionengine). In a more specific implementation that will provide the basisfor further description, but which should not be read to limit theapplication of the general principles to other implementations, theerror correction mechanism may combine a (24,12) Golay code with a16-bit CRC.

The first engine, the Golay engine in this example, generally includes adetection and correction code (“Golay code”) that may be capable ofdetecting and correcting up to three randomly positioned errors per23-bit word. The Golay code is generally a 12- to 23-bit code, which maybe augmented with a parity bit as described below to enable support ofsoft error correction. Specifically, an augmented Golay may be obtainedby adding one parity bit to a 23-bit Golay word in order to form a24-bit augmented Golay word.

The augmented Golay code has the capability of correcting up to fourerrors per word if one or more faulty bit positions can be accuratelypredicted. More precisely, when a faulty bit position is predictedaccurately, the Golay correction engine may correct the correspondingerror bit known as a “soft” error due to the predictable position andthree other error bits, whether or not the positions of those threeother bits are also predictable. When the positions of these error bitsare unpredictable, they generally are referred to as “hard” errors.

Additionally, using the augmented Golay, it is possible to change theratio of hard to soft errors being corrected. For instance, it ispossible to trade one hard error for two soft errors, two hard errorsfor four soft errors, or three hard errors for six soft errors. Forexample: a 3_(—)1 Golay correction mode means that the Golay correctionmode is set to correct three hard errors and one soft error; a 2_(—)3Golay correction mode means that the Golay correction mode is set tocorrect two hard errors and three soft errors; a 1_(—)5 Golay correctionmode means that the Golay correction mode is set to correct one harderror and five soft errors; and a 0_(—)7 Golay correction mode meansthat the Golay correction mode is set to correct zero hard errors andseven soft errors. However, as the number of soft errors to be correctedincreases, so too does the number of error bits to be predicted. In thehardware implementation for a 3_(—)1 Golay correction mode, thecorrection ability is equal to the simpler 3-bit hard Golay correctionif the faulty bit position is unpredictable, but improved if the faultybit position has been or can be predicted correctly. By contrast, forthe other three correction modes identified above (2_(—)3, 15, and0_(—)7), the correction ability of the Golay code could be worse thanthe simple 3-bit hard Golay correction absent an accurate prediction ofat least one, two, or three soft bit positions, respectively.

The soft bits may be identified using various prediction methodologies.For instance, it is possible to identify bits that have the lowestcorrelation values with respect to the transmitted waveform becausethose bits are likely to contain more errors than bits having a highercorrelation value with respect to the transmitted waveform. U.S. Pat.No. 5,872,791 describes one implementation of soft and hard errorcorrection for a Golay-coded word. In that patent, the bits with thelowest weights (i.e., lowest correlation values) generally are flaggedfor soft correction. However, as these identification schemes are usedto merely predict rather than affirmatively identify the location oferroneous bits, they may not be completely reliable and may sometimeslead to the misidentification of error bit positions.

In avoiding and compensating for possible misidentification of errorposition, this error correction mechanism may be modified such that thesoft bit selection includes consideration of bits other than the bitwith the lowest weight. For instance, in addition to the bit with thelowest bit weight, consideration may be given to the bit with the secondlowest bit weight, the bit with the third lowest bit weight, and/orvarious bits up to and including the bit with the lowest bit weight. Theselection of which and how many bits will be considered may bepreconceived or determined on the fly using an algorithm, or throughoperator selection, or by virtue of hardware limitations or capabilitiessince consideration of additional bits generally requires morepermutations of the computation and hence an increased hardware demand.

As generally described above and as illustrated through the exampleprovided below, the first error correction engine (e.g., the Golayengine) typically uses the soft error capabilities to generate not one,but several possible solutions for each input Golay word. Where thenumber of bits identified as candidates for soft correction is five(N=5), the theoretical maximum number of suitable solutions for eachGolay word could be sixteen solutions partitioned as follow:

${\begin{pmatrix}N \\1\end{pmatrix} = {5\mspace{14mu}{solutions}\mspace{14mu}{for}\mspace{14mu}{the}\mspace{14mu} 3\_ 1\mspace{14mu}{mode}}},{\begin{pmatrix}N \\3\end{pmatrix} = {10\mspace{14mu}{solutions}\mspace{14mu}{for}\mspace{14mu}{the}\mspace{14mu} 2\_ 3\mspace{14mu}{mode}}},{\begin{pmatrix}N \\5\end{pmatrix} = {1\mspace{14mu}{solutions}\mspace{14mu}{for}\mspace{14mu}{the}\mspace{14mu} 1\_ 5\mspace{14mu}{mode}}},{{{and}\begin{pmatrix}N \\7\end{pmatrix}} = {0\mspace{14mu}{solutions}\mspace{14mu}{for}\mspace{14mu}{the}\mspace{14mu} 0\_ 7\mspace{14mu}{{mode}.}}}$

Some or all of the solutions may be stored, and the stored solutions maybe ranked based on criteria indicative of their likely accuracy, forexample, a partial correction count value indicating the number ofcorrections made to a word by the first engine.

The second engine, the CRC block detection engine in the example, may beadded for error detection in evaluating blocks of M Golay words(hereinafter “CRC blocks”). Whether one or more solutions are receivedfor a particular word in a CRC block or whether one or more entireblocks are received, the second engine will identify and flag forretransmission or correction blocks that do not pass the CRC test.Furthermore, when more than one solution for a particular word is passedto the second engine, CRC block detection may be used to select apreferred or optimal solution (e.g., a preferred solution amongsolutions having a CRC syndrome equal to “0”). If no acceptable CRCsolution is found, the block may flagged as faulty (for retransmissionor correction).

As generally described above and more specifically described below, theerror correction mechanism includes using the soft bit correctioncapability of a (n, k) error correction mechanism and various aspects ofCRC error detection and correction in novel ways. For instance, theerror correction mechanism may include several features, namely:

-   -   Relaxing the soft bit position selection. Indeed, instead of        constraining the soft bit position to a single position, namely        the bit with the lowest correlation value with the transmitted        waveform, bits more than generally having lowest correlation        values may be selected and evaluated as possible candidates for        soft correction.    -   Automatically performing multiple runs using combinations of        soft bit positions and combinations of correction modes (3_(—)1,        2_(—)3, 1_(—)5, and 0_(—)7).    -   Using the detection capabilities of the CRC engine to select        from among more than one blocks that do not include a CRC error        (0 syndrome), if any exist, effectively using the CRC engine for        error detection and error correction.    -   Performing soft correction in parallel using two soft correction        engines.

A more detailed description of one exemplary implementation now follows.For simplification and for discussion of this implementation, thefollowing assumptions are made, which should not diminish the generalityof the algorithm.

-   -   The number of soft bits N used in the soft error correction        engine is N=5;    -   The number of solutions K per Golay is K=15;    -   The size of the CRC block is M Golay 12-bit words with M=16;    -   The size of the CRC block is M′ data 16-bit words with M′=12;    -   The number of Golay word results with two possible decoding        choices in any CRC block is D=5, hence 2⁵=32 possible CRC        solutions.

A different error correction code may produce a different M to M′ ratio.For instance, in an alternate (n, k) code in which a k-bit data word isencoded as n-bit transmitted symbols or words, the M to M′ ratio may bedetermined by the CRC block size chosen, such that M is an integermultiple of the CRC length and M′ is an integer multiple of k. In thepresent implementation, the CRC block size is M Golay 12-bit words whereM=16, and the CRC block size is M′ data 16-bit words where M′=k=12, sothe M to M′ ratio is 16/k. The n-bit length of the encoded transmittedsymbol or word affects the design of the hardware in that n/k clocks areused to transmit each bit of useful data. Since the Golay code is a (24,12) code, this implementation uses 32 clocks for each 16-bit data wordin the CRC layer, which ratio conveniently allows five of the Golaywords to have two possible decoding choices, each (D=5).

FIG. 1 shows an exemplary encoding and transmission process 100. Process100 includes using a transmitter that generally prepares a sequence ofM′−1 (i.e., 11) 16-bit words (step 110). This sequence may beconcatenated into a serial word or polynomial (step 120), for which aCRC remainder is generated through division of the serial word by a16-bit CRC polynomial (step 130), for example, polynomial, 1010 00000000 0001, which may be known as CRC16. By appending the CRC remainderto the 11 16-bit words accepted for transmission (step 140), CRC blockshaving 12 16-bit words may be formed from the serial word andtransmitted.

CRC blocks of this dimensionality may be realized as M (e.g., 16) 12-bitwords (step 150). These 12-bit words are typically multiplied by an1-bit Golay polynomial (G) to generate 23-bit data words (step 160) towhich an extra parity bit may be added to generate augmented Golay datawords having 24 bits (step 170). The Golay data bits may be modulatedonto the transmission medium thereafter (step 180).

FIG. 2 shows an exemplary receiving and decoding process 200, whichgenerally reverses the transmitter process 100 of FIG. 1. Process 200generally includes synchronizing (step 210) and equalizing (step 220) aninput transmission signal that has been over-sampled. Aftersynchronization (step 210) and equalization (step 220), the signal isdemodulated (step 230) to produce a stream of bits and their relativestrengths, for example, according to equation 1.

$\begin{matrix}\begin{matrix}{{Bit\_ Weight} = {\sum\limits_{i = {1\ldots\mspace{11mu}{Number\_ samples}{\_ per}{\_ Bit}}}{{{received\_ Bit}\lbrack i\rbrack}*}}} \\{{\mspace{59mu}{~~}}{{transmitted\_ Bit}\;\lbrack i\rbrack}}\end{matrix} & {{Equation}\mspace{14mu} 1}\end{matrix}$

This is, for each received 24-bit Golay word, the 24 bits of the Golayword are sorted and the N (e.g., 5) lowest bit weight values areidentified in an index list (“erasure list”) using equation 1 above(step 240). Within the erasure list, these values are generally listedin an ascending order as erasure positions that identify the N weakestbits in a Golay word. Once sorted, the 24-bit words are passed to theGolay correction engine (step 250), which correction engine produces aresult (e.g., one or more 12-bit words) that is passed to the secondengine (e.g., a CRC engine) for further error detection and correctionprocessing (step 260). Exemplary operations performed by the first andsecond engines (steps 250 and 260) are described in detail with respectto FIGS. 3-5.

Referring to FIG. 3 a, the Golay correction engine may include two ormore engines of similar or divergent types (e.g., the two engines bothmay have the Meggitt decoder design, both may have some other similardesign, or each may have a divergent design). These two engines may beconfigured to solve the correction equations serially (not shown) suchthat a pair of solutions are produced for each arriving 24-bit Golayword initially at the same rate. Alternatively, as shown for example byFIG. 3 a, the two engines 301 a and 301 b may be configured in parallelsuch that they are capable of solving the correction in parallel usingfewer clock cycles (e.g., one clock cycle), which may be significantlyfaster than the data is received (e.g., every 24 or 32 clock cycles). Inany event, the result produced by each engine typically includes a12-bit data word.

Referring to FIG. 3 b, one implementation of soft Golay corrections 250is described under an assumption that five soft bits are used by theGolay correction engine (i.e., N=5). In a first of two Golay enginesoperating in parallel, each of the five erasure bits may be set to 1(step 310 a), and in the other of the two Golay engines, each of thefive erasure bits may be set to 0 (step 310 b). Error correction isperformed by both engines on bits including some or all of the erasurebits (steps 320 a and 320 b) and the number of corrections other thanthe erasure bits (e.g., a partial correction count value) may begenerated for the outputs from each engine (steps 330 a and 330 b).Based on those outputs and the partial correction count values, theengine output having a lowest partial correction count value isidentified (step 340) and selected (steps 350 and 360). For instance, ifthe partial correction count value is lower for the first Golay engine,then the corrected output of that Golay engine may be selected (step350). Conversely, if the partial correction count value is lower for thesecond Golay engine, then the corrected output of that engine may beselected (step 360). Moreover, the data produced by or concerning thetwo engines includes a measure of how much correction each has performedin generating its result. The engine with the lowest partial correctioncount value generally has the strongest probability of producing thecorrect result so the corresponding 12-bit data result is saved. In thisprocess, the partial correction count value does not typically take intoaccount the corrections to the erasure bits, and the non-selected engineresults typically are ignored.

The two engines generally produce one pair of results every clock cycle,where the results having a lower partial correction count value arepreserved for further processing. Thereafter, during clock cycles priorto the receipt of a next pair of engine results (32 clock cycles in thisexample), several different permutations of erasure patterns may beidentified based on different combinations of the erasure bits andtested. The number of permutations for testing (K) may be selectable,from one to the number of permutations possible given time and resourceconstraints (step 370). For illustrative purposes, fifteen permutations(K=15) are selected. Assuming fifteen permutations, during each of thefirst five clock cycles, only one of the erasure bits within the resultmay be tested generally starting with the very weakest erasure bit(e.g., the bit having the lowest correlation) and moving to thestrongest of the erasure bits. For the following clock cycles, variouscombinations of erasure patterns may be tested. In this example, sincefifteen (15) permutations are allowed, ten (10) additional erasurepatterns including any of two, three, or four out of the five erasurebits may be chosen, again starting with the weakest combination andmoving to stronger combinations, the more weak therefore beingprioritized over the less weak.

In this example, after 15 clocks, as many as 15 unique solutions couldbe obtained (step 370). However, only a few solutions are usually uniqueand typically only one unique solution is produced over and over,particularly when the signal strength is fair, good, or very good.Nevertheless, the results in the solution set are ranked and a thresholdnumber are saved in a buffer (“ranking box”) capable of holding thedesired number of unique results (e.g., 7), with the very first resulttypically being labeled as the preferred result since it was computedbased on the perceived weakest single erasure bit (step 380). Thecapacity of the holding buffer may be selected by considering the sizeappropriate for handling a noisy signal situation, in which the numberof solutions may be larger than one. However, for purposes of thisdescription, the choice of seven (7) results is arbitrary.

The ranking box also may store the corresponding partial correctioncount value (or some related metric) as an “uncertainty” tag. If theranking box is presented with a result that is already in the box, onlyone copy of the result is generally maintained with the lowest partialcorrection count value of the duplicates to indicate that this resultmight in fact be the correct result.

Ordinarily, the first result stored in the ranking box is presented asthe default correct result to the CRC engine since it tends tocorrespond to a result based on the erasure bit having a lowest partialcorrection count value. However, any of the results stored in the buffercould be presented as the default correct result based on otherappropriate criteria.

In addition, one or more alternative correction results may be presentedwith the default correction result. These alternative correction resultstypically are selected based on criteria suggesting that they areslightly less likely, equally likely, or more likely than the defaultcorrection result to be the correct result.

For instance, FIG. 3 c illustrates one implementation of presenting oneor more solutions (step 380). The first result may be selected as thedefault result to be presented (step 380 a). If there are no otherunique results (step 380 b), then the default result may be presentedmore than once (e.g., twice) (step 380 c). If there are other uniqueresults (step 380 b), then it may be determined whether the number ofunique results meets or exceeds a threshold number of unique results(e.g., four) (step 380 d). Alternatively, it may be determined whetherthe number of unique results exceed one and whether the partialcorrection count value for one of the unique results is similar to thepartial correction count value of the default result (step 380 d). Ifneither of the criteria is met (step 380 d), then the default result maybe presented more than once (e.g., twice) (step 380 c). If at least oneof the criteria is met (step 380 d), then it is determined whether athreshold number of prediction flags have been raised (e.g., five) forthis CRC block (step 380 e). If, for example, five prediction flags havebeen raised for this CRC block, then the default result may be presentedmore than once (step 380 c). If, for example, fewer than five predictionflags have been raised for this CRC block, then a prediction flag may beraised and an alternate result may be presented with the default result(step 380 f).

A prediction flag may be presented along with one or more particularcorrection results to identify situations for which more than onecorrection result is presented corresponding to a single Golay word. Theprediction flag may be concatenated with the correction results or maybe made otherwise accessible to the CRC engine. For instance, theprediction flag may be concatenated with a particular Golay word, it maybe concatenated with a block of Golay words, or it may be madeaccessible using a shared memory resource.

After this Golay error correction process 300, the M (e.g., 16) 12-bitdata words typically are realized as default and/or alternate streams ofM′ (e.g., 12) 16-bit words, every four Golay 12-bit words producingthree 16-bit words. It is also possible to concatenate default andalternate correction results into a single stream, to concatenate onlyselective (e.g., uncertain) correction results into the single stream,or produce 2^(X) separate streams.

In one implementation, e.g., where 2^(X) separate streams were presentedby the first engine (e.g., Golay engine), each separate stream may bestored in a separate FIFO and received at 2^(X) CRC engines. Forinstance, the first engine may output 32 (i.e., 2⁵) separate streamsthat may be received at 32 CRC engines. The CRC engines may process eachstream separately by dividing each received stream by the CRC polynomialused by the transmitter to produce a CRC remainder for each stream. EachCRC remainder then may be compared with the CRC remainder received withthe original transmission to determine a CRC syndrome for each stream.The first stream where the CRC remainders match (i.e., the CRCsyndrome=0), then that stream may be read from the appropriate FIFO as acorrectly received stream. If none of the CRC remainders match, then thestreams may be deemed to have been received incorrectly such that thetransmitted stream needs to be repaired or re-fetched.

In one implementation, 2^(X) CRC engines may be realized by having oneCRC engine that rotates through the data streams outputted by the Golayengine by performing a time-division operation on the incoming streams.In this instance, the first stream and the last stream outputted fromthe Golay engine may be stored in memory using, for instance, twomemories. Following the CRC processing of the streams, the correctlyreceived stream (i.e., the stream where the CRC syndrome=0), may berealized from the first stream in memory, the last stream in memory, ora combination of portions of the first and the last stream from the twomemories.

In another implementation, e.g., where one or more continuous streamsare presented by the first engine, the CRC process 260 may be performedas shown by FIG. 4. The CRC process 260 may include receiving, forexample, at one or more CRC engines, one or more streams of 16-bit wordsfrom the Golay engine as a single continuous serial block (step 410). Apartial CRC remainder is generally calculated for each Golay word duringone, some, or all of the 32 clock cycles generally required to receivethat word in the example used for illustration purposes (step 420). TheCRC polynomial used by the transmitter is used for this calculation.Once all of the Golay words within the serial block are received, thepartial CRC remainders are used to generate a complete remainder that iscompared against the CRC remainder received with the originaltransmission to determine a CRC syndrome. If the CRC remainders match,the CRC syndrome is 0 (step 430), and the CRC data is deemed authenticand accurate (step 440). However, if the CRC syndrome is not 0 (step430), the block of data is deemed to have been received incorrectly suchthat the block needs to be repaired or re-fetched (step 450).

In general, a block of data may include any number of words. However,the longer the block, the fewer the number of required CRC remaindersand hence the smaller the required bandwidth, processing load andexpense in transmitting the data CRC syndrome. But, with increased blocklength comes an increased likelihood that the block may include anuncorrectable error and an increased block length for the requiredretransmission. In fact, if the blocks are too long and/or the channelis too noisy, then too many blocks may be corrupted that requireretransmission, and thus, throughput may decrease. By contrast, if theblocks are relatively short, they may be received much more robustly,but the CRC payload may be more significant.

CRC hardware may be implemented by serial division with hardware quitesimilar to that used in serial error correcting hardware but with adifferent polynomial, with or without a correction capability. Forinstance, the CRC hardware may be implemented in parallel, similar tothe Golay correction engine. For example, a single CRC engine ormultiple CRC engines may receive, as input, two streams of output fromthe Golay engine and may process each stream in parallel (e.g., in oneclock cycle). One implementation of a single CRC engine is describedbelow with reference to FIGS. 5 a and 5 b.

Referring to FIG. 5 a, two streams of M′ 16-bit words 501, 502 may bereceived by the CRC engine 503 from the Golay engine (not shown). TheCRC engine 503 may include a single input at which the CRC engine 503alternates between the two streams 501, 502, or more than one input. Thestreams 501, 502 may differ from one another by one or more of the16-bit words. More specifically, for example, where X=5, the streams501, 502 may differ from one another by up to five Golay words (whichmay correspond to an equal or greater number of 16-bit words if one ormore of the Golay words span more than one 16-bit word). In oneimplementation, where X is increased, the streams 501, 502 may differfrom one another by more than five Golay words, provided that the numberof clock cycles between words is sufficiently increased to allow anumber of computations necessary to account for the increased number ofdiffering words between the two streams 501, 502.

In this implementation presented for illustration purposes, the CRCengine 503 receives a 16-bit word once every 32 clock cycles (the Golaycode reduced 24 to 12 bits (or clocks)), and the CRC engine performs apartial 16-bit division in 1 clock cycle on the 16-bit word. Thus, afterthe CRC engine 503, it is generally available for processing for thenext 31 clock cycles to calculate the partial division on the 16-bitword while it awaits the next 16-bit word. During this otherwise idletime, the CRC engine may be used to recompute the computation performedon the first received 16-bit word redundantly 31 additional times.

When streams 501 and 502 do not differ, or only one possibility for eachword is selected from the two streams notwithstanding differencesbetween them, the results produced by these redundant computationsshould be the same for all 32 clock cycles of each 16-bit word that isprocessed, and, therefore the 32 syndromes produced at the end of the16-bit word block should be the same.

However, when streams 501 and 502 differ and those differences areprocessed by the CRC engine 503, one or more of the computation resultswill differ, identifying correct and incorrect settings for the bitscorresponding to a predicator flag in the Golay error correction. Forinstance, in the following examples, streams 501 and 502 differ by two16-bit words, in the positions of the streams identified by a firstprediction flag and corresponding to the words labeled 1 b and 2b and bya second prediction flag and corresponding to the words labeled 1 d and2 d. For all other positions, the 16-bit words in each stream are thesame.

The CRC engine 503 processes the first word (1 a) in each stream,alternating between the first stream and the second stream for the CRCengine input, and should obtain the same partial CRC remainder 32 times,as illustrated by the first line of index 504 which contains a list ofthe CRC partial remainders that are built as the CRC engine 503 movesthrough words in the block. For example purposes, the resulting listincludes the partial remainder for 1 a a total of 32 times.

Next, the CRC engine 503 processes the second word 1 b, 2 b in eachstream. The Golay engine may indicate the position of a word thatincludes both a default word and an alternate word through the use ofthe prediction flag. In this instance, the first prediction flag may beused to indicate that the second word in each stream 1 b, 2 b differ,perhaps because the Golay engine outputted default and alternatecorrection results for this particular word. When the CRC engine 503processes the second word in each stream, it alternates between streamsfor the input, as it did with the first word. Thus, the CRC engine 503computes a partial remainder for word 1 a and includes that remainder tothe index 504 under CRC remainder 1. The CRC engine then computes apartial remainder for word 1 b and includes that remainder in the index504 under CRC remainder 2. This process is repeated for the durationtotal of the 32 clock cycles. At this point, the index includes partialremainders for the first two words, which would have two different totalremainders repeated 16 times. If the streams 501, 502 did not includeany further prediction flags, the index would include two differentremainders repeated 16 times each. For example, CRC remainder 1 wouldinclude the first remainder, CRC remainder 2 would include the secondremainder, CRC remainder 3 would include the first remainder, CRCremainder 4 would include the second remainder, and so forth through CRCremainder 32.

In this illustration, however the streams differ by two words such thattwo prediction flags are included to indicate the two positions in thestreams that diverge, one stream having a default word and the otherhaving an alternate word. In this instance, the second prediction flagoccurs at words 1 d, 2 d. As it is the second prediction flagencountered, and thus the second word for which two possibilities exist,there are four (2²=4) potential variations among the two positions inquestion, and hence the block thus far. To address each of thesepossibilities, when the CRC engine 503 processes these two words, itadds their partial remainders to the index 504 in a manner thatestablishes a total of four (4) different combinations. For instance, asillustrated by FIG. 5 a, it is possible to alternate between stream 501and stream 502 by steps of two (2) corresponding to the rank of thepredictor flag to accomplish these different combinations. In thismanner, just like the first three (3) words, the particular word beingprocessed is so processed sixteen (16) times, but each of the four (4)combinations appear only eight (8) times out of the 32 possible results.

Similarly, if a third prediction flag were set indicating the existenceof a third word within the block for which alternative correctionresults exist, there would be eight (2³=8) potential variations amongthe now three words in question, and hence the block thus far. Toaddress each of these possibilities, when the CRC engine processes thesetwo words, it adds their partial remainders to the index 504 in a mannerthat establishes all eight (8) different combinations. For instance,maintaining consistency with the example provided above for the secondprediction flag and the illustration provided by FIG. 5 a, it ispossible to alternate between streams 501 and 502 by steps of four(2²=4).

As the number of prediction flags continues to increase, so to will thenumber of words in question, the number of potential variations amongthe now-increased number of words in question, and, in the exampleprovided above for up to three prediction flags, the step size whenalternating between received streams 501 and 502. For instance,extrapolating from the above example, a relationship may be definedbetween the number of prediction flags for a block, the number ofpotential combinations in the words of that block, and the step sizethat may be used to iteratively derive the different combinations, asindicated in table 1 below:

TABLE 1 Number of Number of Potential Step Size Flags (F) Combinations(2^(F)) (2^(F-1)) 0 2⁰ = 1 0 (no variations) 1 2¹ = 2 2⁰ = 1 2 2² = 4 2¹= 2 3 2³ = 8 2² = 4 4  2⁴ = 16 2³ = 8 5  2⁵ = 32  2⁴ = 16 . . . . . . .. . X 2^(X) 2^(X-1)

FIG. 5 b illustrates the flow of the operation of FIG. 5 a in a flowchart. As described above with respect to step 410 of FIG. 4, the firsterror correction engine (e.g., the Golay engine) produces two streamsreceived by the CRC engine input. Thereafter, process 420 of FIG. 5 bincludes determining whether the prediction flag is set to reflect lowconfidence for one or more words in the streams (step 510). For everyblock of data, several Golay results may be accepted as low confidenceby observing the prediction flag described earlier. In oneimplementation, for example, where 32 clock cycles are required tocommunicate adjacent words in a data block, a maximum of 5 (2⁵=32) Golayresults may be accepted as low confidence by observing the predictionflag. When the error correction engine does not produce a predictionflag (step 510), it may output the default word in duplicate to twoserial streams (step 520). When it outputs a prediction flag (step 510),it directs the default result (step 530 a) and an alternate result (step530 b) to the two streams. Now, the CRC engine has 32 clock cycles totest the solutions by switching the input between the two sources. Thesteering logic follows the arrival of prediction flags.

If one prediction flag is placed over one Golay word in a block (step540), then the two streams will be the same for all but one Golay word.But since the two streams differ by one word, the resulting CRCremainders will be different. In this example, the CRC engine willproduce the two different results 16 times each for that word over the32 clock cycles (step 545). The results may include the partialremainder and may be interleaved in the index, for example, 1 a 2 a, 1 a2 b, 1 a 2 a, 1 a 2 b, . . . using the convention of FIG. 5 a.

If two predictions flags are placed over two Golay words in a block(step 550), then the two streams will be the same for all but two Golaywords. But since the two streams differ by two words in unrelatedpositions, the resulting CRC remainders will be different. In practice,over the 32 clock cycles, the CRC engine typically produces twodifferent results 16 times each for that word, and four differentcombinations eight times each (step 555). The results may include thepartial remainder and may be interleaved in the index, for example, 1 a2 a 3 a 4 a, 1 a 2 b 3 a 4 a, 1 a 2 a 3 a 4 b, 1 a 2 b 3 a 4 b, 1 a 2 a3 a 4 a, 1 a 2 b 3 a 4 a, 1 a 2 a 3 a 4 b, 1 a 2 b 3 a 4 b, . . . usingthe conventions of FIG. 5 a.

If three prediction flags are placed over three Golay words in a block(step 560), then the two streams will be the same for all but threeGolay words. But since the two streams differ by three words inunrelated positions, the resulting CRC remainders will be different. Inpractice, over the 32 clock cycles, the CRC engine typically producestwo different results 16 times each for that word, and eight differentcombinations four times each (step 565). The results may include thepartial remainder and may be interleaved in the index using theconventions of FIG. 5 a.

If four prediction flags are placed over four Golay words in a block(step 570), then the two streams will be the same for all but four Golaywords. But since the two streams differ by four words in unrelatedpositions, the resulting CRC remainders will be different. In practice,over the 32 clock cycles, the CRC engine typically produces twodifferent results 16 times each for that word, and sixteen differentcombinations interleaved in the index using the conventions of FIG. 5 a.

If five prediction flags are placed over five Golay words in a block(step 580), then the two streams will be the same for all but five Golaywords. But since the two streams differ by five words in unrelatedpositions, the resulting CRC remainders will be different. In practice,over the 32 clock cycles, the CRC engine typically produces twodifferent results 16 times each for that word, and thirty two differentcombinations once each (step 585).

Where words within a block are received with a separation of only 32(2⁵) clock cycles, a retransmission may be necessary (step 595) if thereare greater than 5 prediction flags (step 590). In an alternativeimplementation, once the threshold number of prediction flags isencountered, then further prediction flags may be ignored and processingmay proceed as if no other prediction flags exist.

The CRC engine may arrange the incoming streams to change based on whichcombination of predictions is encountered. At the beginning of a block,before a prediction flag is encountered, all partial remainders andtherefore all 32 syndromes are the same. However, as each predictionflag is encountered by the CRC engine, the number of possiblecombinations increases by a factor of two. The state of the CRC enginereceives words from within the block until a threshold limit ofprediction flags is reached, X=5 in the preeminent example above. Solong as the threshold limit is not exceeded, the CRC engine maysynchronize all the timing to make it seem as if there were 32 separateserial CRC engines working in parallel.

Thus, in the example, the number of predictions may include five orfewer predictions. At the end of each CRC block, the indexed list ofremainders may be compared to the CRC remainder value communicated withthe transmitted signal to locate the first 0 syndrome. If a 0 syndromeis found, the position of the corresponding remainder on the index maybe used to identify the data used to produce that remainder, andultimately the syndrome, from the two streams saved in two memorylocations (step 597). Moreover, when the final CRC index is complete,the positions of remainders within the index may be described using a5-bit index value (2⁵), and the data may be extracted from the memorylocations in a manner corresponding to the 5-bit index. For example, ifno 0 syndrome is found, then the block may reported as bad andretransmission may be necessary.

For instance, if the first CRC syndrome was 0, (index=0) then the datamay be read directly from the default memory in order it was writtensince no predictions were needed, even if several were used.

If the second CRC syndrome is 0, the corresponding CRC index has a valueof 1 (00001) such that the data may be read directly from the defaultmemory in order it was written except for the one alternate word locatedin the 2nd memory at a position identified by the first prediction flag.

If the third CRC syndrome is 0, the corresponding CRC index has a valueof 2 (00010) such that the data may be read directly from the defaultmemory in order it was written except for the one alternate word locatedin the 2nd memory at a position identified by the second predictionflag.

If the fifth CRC syndrome is 0, the corresponding CRC index has a valueof 4 (00100) such that the data may be read directly from the defaultmemory in order it was written except for the one alternate word locatedin the second memory at a position identified by the third predictionflag.

If the ninth CRC syndrome is 0, the corresponding CRC index has a valueof 8 (01000) such that the data may be read directly from the defaultmemory in order it was written except for the one alternate word locatedin the second memory at a position identified by the fourth predictionflag.

If the seventeenth CRC syndrome is 0, the corresponding CRC index has avalue of 16 (10000) such that the data may be read directly from thedefault memory in order it was written except for the one alternate wordlocated in the second memory at a position indicated by the fifthprediction flag.

In the above five cases, one bit was needed to repair the data streameven though other bits may have been, in effect, albeit ineffective.

It is also possible for more than one bit to have to be used incombination, in which case the resulting CRC index value will yield morethan one 1. For instance, if the thirty second CRC syndrome was 0, thecorresponding CRC index has a value of 31 (11111) such that the data maybe read directly from the default memory in order it was written exceptfor the five alternate words located in the second memory at positionsidentified by the first, second, third, fourth, and fifth predictionflags. For an example having a maximum of five soft bits (N=5), this maybe the most serious correction case and may occur if the data sourcefrom the signal repeatedly throws weak data into the Golay engines.

A more advanced version of the engine having the same basic design couldbe even more effective, by over-clocking the CRC engine 2, 4, 8, or2^(Y) times. The number of permutations increases by the increasedamount of over-sampling, allowing an additional one, two, three, or Yextra predictions per block.

As described above, an error correcting algorithm has been designed thatuses an (n, k) error correcting block code, soft error correction and aCRC to produce a new flexible algorithm that has includes additionalerror correcting capabilities. The algorithm may be effective in theintended application, in part, because the CRC engine often choosescorrected data unavailable to the previous unaided design. This leads tomuch higher throughput in noisy channels.

As described above in one implementation, the results of the Golaycorrection process may include a default result and an alternate resultas indicated, for example, by a prediction flag. In anotherimplementation, it is possible for the results of the Golay correctionprocess to include a default result and more than one alternate result.Consistently, it is possible for the CRC engine to analyze a default andmore than alternate result.

The described systems, methods, and techniques may be implemented indigital electronic and/or analog circuitry, computer hardware, firmware,software, or in combinations of these elements. Apparatus embodyingthese techniques may include appropriate input and output devices, acomputer processor, and a computer program product tangibly embodied ina machine-readable storage device for execution by a programmableprocessor. A process embodying these techniques may be performed by aprogrammable processor executing a program of instructions to performdesired functions by operating on input data and generating appropriateoutput. The techniques may be implemented in one or more computerprograms that are executable on a programmable system including at leastone programmable processor coupled to receive data and instructionsfrom, and to transmit data and instructions to, a data storage system,at least one input device, and at least one output device. Each computerprogram may be implemented in a high-level procedural or object-orientedprogramming language, or in assembly or machine language if desired; andin any case, the language may be a compiled or interpreted language.Suitable processors include, by way of example, both general and specialpurpose microprocessors. Generally, a processor will receiveinstructions and data from a read-only memory and/or a random accessmemory. Storage devices suitable for tangibly embodying computer programinstructions and data include all forms of non-volatile memory,including by way of example semiconductor memory devices, such asErasable Programmable Read-Only Memory (EPROM), Electrically ErasableProgrammable Read-Only Memory (EEPROM), and flash memory devices;magnetic disks such as internal hard disks and removable disks;magneto-optical disks; and Compact Disc Read-Only Memory (CD-ROM). Anyof the foregoing may be supplemented by, or incorporated in,specially-designed ASICs (application-specific integrated circuits).

It will be understood that various modifications may be made withoutdeparting from the spirit and scope of the claims. For example,advantageous results still could be achieved if steps of the disclosedtechniques were performed in a different order and/or if components inthe disclosed systems were combined in a different manner and/orreplaced or supplemented by other components. For example, thetechnologies described above may be applied to data transmitted overdifferent transmission media, such as, for example, power lines,telephone lines, cable lines, digital subscriber lines (DSL), integratedservices digital network (ISDN) lines, radio frequency (RF) media, andother transmission media. Accordingly, other implementations are withinthe scope of the following claims.

1. A method for performing soft error correction, the method comprising:receiving a word at a soft correction engine capable of operating in atleast first and second correction modes that have different ratios ofhard errors to soft errors, wherein a soft error relates to a faulty bitwhose position is predictable and a hard error relates to a faulty bitwhose position is not accurately predictable; identifying soft bitpositions within the word; and generating, based on the identified softbit positions, a number of possible results for the received word usingcombinations of the identified soft bit positions and the at least thefirst and second correction modes that have different ratios of harderrors to soft errors.
 2. The method as in claim 1 wherein the possibleresults include default results and alternate results, the methodfurther comprising selecting among at least one of the default resultsand alternate results within the possible results as possible correctsolutions based on a metric representing a likelihood of correctness. 3.The method as in claim 2 wherein the metric includes a lowest partialcorrection count value.
 4. The method as in claim 1 further comprisinginputting at least one result from among the number of possible resultsinto an error handling engine for error detection.
 5. The method as inclaim 4 wherein the error handling engine includes a cyclic redundancycheck (CRC) engine.
 6. The method as in claim 1 further comprisinginputting a default result and an alternate result from among thepossible results into an error handling engine for selection of acorrect solution as between the default result and the alternate result.7. The method as in claim 6 wherein the error handling engine includes aCRC engine.
 8. The method as in claim 6 wherein inputting the defaultresult and the alternate result includes inputting the default resultand the alternate result that differs from the default result by one ormore words into the error handling engine for selection of the correctsolution as between the default result and the alternate result.
 9. Themethod as in claim 1 wherein the soft correction engine includes a Golayengine.
 10. The method as in claim 1 wherein receiving the word includesreceiving the word at a first soft correction engine and furthercomprising: receiving the word at a second soft correction engine thatis capable of operating in at least first and second correction modesthat have different ratios of hard errors to soft errors and isstructured and arranged to operate in parallel with the first softcorrection engine; performing, in parallel, soft error correction on thereceived word at both the first soft correction engine and the secondsoft correction engine; and generating a number of possible results forthe received word at both the first soft correction engine and thesecond soft correction engine.
 11. The method as in claim 10 wherein thefirst soft correction engine and the second soft correction engineinclude a Golay engine.
 12. A system for performing soft errorcorrection, comprising: means for receiving a word at a soft correctionengine capable of operating in at least first and second correctionmodes that have different ratios of hard errors to soft errors, whereina soft error relates to a faulty bit whose position is predictable and ahard error relates to a faulty bit whose position is not accuratelypredictable; means for identifying soft bit positions within the word;and means for generating, based on the identified soft bit positions, anumber of possible results for the received word using combinations ofthe identified soft bit positions and the at least the first and secondcorrection modes that have different ratios of hard errors to softerrors.
 13. The system of claim 12 wherein the possible results includedefault results and alternate results, further comprising means forselecting among at least one of the default results and alternateresults within the possible results as possible correct solutions basedon a metric representing a likelihood of correctness.
 14. The system ofclaim 13 wherein the metric includes a lowest partial correction countvalue.
 15. The system of claim 12 further comprising means for inputtingat least one result from among the number of possible results into anerror handling engine for error detection.
 16. The system of claim 15wherein the error handling engine includes a CRC engine.
 17. The systemof claim 12 further comprising means for inputting a default result andan alternate result from among the possible results into an errorhandling engine for selection of a correct solution as between thedefault result and the alternate result.
 18. The system of claim 17wherein the error handling engine includes a CRC engine.
 19. The systemof claim 17 wherein the means for inputting the default result and thealternate result includes means for inputting the default result and thealternate result that differs from the default result by one or morewords into the error handling engine for selection of the correctsolution as between the default result and the alternate result.
 20. Thesystem of claim 12 wherein the soft correction engine includes a Golayengine.
 21. The system of claim 12 wherein the means for receiving theword includes means for receiving the word at a first soft correctionengine and further-comprising: means for receiving the word at a secondsoft correction engine that is capable of operating in at least firstand second correction modes that have different ratios of hard errors tosoft errors and is structured and arranged to operate in parallel withthe first soft correction engine; means for performing, in parallel,soft error correction on the received word at both the first softcorrection engine and the second soft correction engine; and means forautomatically generating a number of possible results for the receivedword at both the first soft correction engine and the second softcorrection engine.
 22. The system of claim 21 wherein the first softcorrection engine and the second soft correction engine include a Golayengine.